package com.java.sparsearray;

import java.io.*;

/**
 * 数据结构与算法：稀疏数组练习
 * 五子棋
 *
 * @author 19252
 */
public class SparseArray {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 首先创建一个原始二维数组 11 * 11
        // 0：表示没有棋子，1表示黑棋，2表示蓝棋
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[4][5] = 2;
        // 遍历二维数组
        for (int[] array : chessArr1) {
            for (int data : array) {
                System.out.print("  " + data);
            }
            System.out.println();
        }
        // 将二维数组转换为稀疏数组的思想
        // 1. 将二维数组遍历，得到数据为0的个数
        int count = 0;
        for (int[] ints : chessArr1) {
            for (int j = 0; j < chessArr1[0].length; j++) {
                if (0 != ints[j]) {
                    count++;
                }
            }
        }

        //2. 建立对应的稀疏数组, 稀疏数组的行一定是为不为0的数据总数加一(多出来的一行用来保存原二维数组的大小)，
        // 列为3列 row col value
        int[][] sparseArr = new int[count + 1][3];
        // 稀疏数组的第一行保存，原二维数组的大小，和非0 元素的个数
        // row 的值为原二维数组的行数
        sparseArr[0][0] = chessArr1.length;
        // col 的值为原二维数组的列数
        sparseArr[0][1] = chessArr1[0].length;
        // value 的值为原二维数组的非0元素个数
        sparseArr[0][2] = count;
        int rows = 1;
        // 再次遍历原二维数组，将值存入稀疏数组
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[0].length; j++) {
                if (0 != chessArr1[i][j]) {
                    sparseArr[rows][0] = i;
                    sparseArr[rows][1] = j;
                    sparseArr[rows][2] = chessArr1[i][j];
                    rows++;
                }
            }
        }

        // 输出稀疏数组验证
        for (int[] ints : sparseArr) {
            for (int j = 0; j < sparseArr[0].length; j++) {
                System.out.print("  " + ints[j]);
            }
            System.out.println();
        }

        // 稀疏数组序列化
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./sparsearray/result/sparseArr.data", true));
        outputStream.writeObject(sparseArr);

        // 稀疏数组反序列化
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./sparsearray/result/sparseArr.data"));
        int[][] newSparseArr = (int[][]) inputStream.readObject();
        inputStream.close();
        // 序列化之后读取出来的稀疏数组
        for (int[] ints : newSparseArr) {
            for (int j = 0; j < newSparseArr[0].length; j++) {
                System.out.print("  " + ints[j]);
            }
            System.out.println();
        }
        // 恢复初始状态二维数组
        int[][] chessArr2 = new int[newSparseArr[0][0]][newSparseArr[0][1]];
        for (int i = 1; i < newSparseArr.length; i++) {
            int row = newSparseArr[i][0];
            int col = newSparseArr[i][1];
            int value = newSparseArr[i][2];
            chessArr2[row][col] = value;
        }

        // 遍历重新获取的二维数组
        for (int[] ints : chessArr2) {
            for (int j = 0; j < chessArr2[0].length; j++) {
                System.out.print("  " + ints[j]);
            }
            System.out.println();
        }
    }
}
